package com.xfcycle.zebrabikegp.util;

import android.util.Log;

/**
 * 将字符串转化为16进制字符串
 * Created by xFcycle on 2017/5/8.
 */

public class TransStringUtil {

    private static final String TAG = "TransStringUtil";

    /**
     * 将字符串转化为16进制字符串
     *
     * @param str 需要转化的字符串
     * @return 返回的16进制字符串，无空格
     */
    public static String str2HexStr(String str) {

        return byte2HexStr(str.getBytes());
    }


    /**
     * 将16进制字符串转化为普通字符串
     *
     * @param hexStr 需要转换的16进制字符串，中间无空格，例：5CD8A
     * @return 转化完成的可读字符串
     */
    public static String hexStr2Str(String hexStr){

        return new String(hexStr2Bytes(hexStr));
    }

    /**
     * 将byte数组转换为16进制字符串
     *
     * @param b 需要转换的byte数组
     * @return string 每个byte值之间无空格分割,个位数字用例如 01 的格式表述
     */
    public static String byte2HexStr(byte[] b) {
        String stmp = "";
        StringBuffer sb = new StringBuffer();

        for (int i = 0; i < b.length; i++) {
            stmp = Integer.toHexString(b[i] & 0xff);
            sb.append(((1 == stmp.length()) ? "0" + stmp : stmp));
        }
        return sb.toString();
    }

    /**
     * 将16进制字符串转化为byte数组
     *
     * @param hexStr 需要转化的16进制字符串
     * @return 转化得到的byte数组
     */
    public static byte[] hexStr2Bytes(String hexStr) {

        int m = -1, n = -1;
        int l = hexStr.length() / 2;
        byte[] ret = new byte[l];
        for (int i = 0; i < l; i++) {
            m = i * 2 + 1;
            n = m + 1;
            ret[i] = Byte.decode("0x" + hexStr.substring(i * 2, m) + hexStr.substring(m, n));
        }
        return ret;
    }

    /**
     * 将普通字符串转化为Unicode的字符串
     *
     * @param str 需要转化的字符串
     * @return 转化完成的Unicode字符串
     */
    public static String str2Unicode(String str) {
        char c;
        int intAsc = -1;
        StringBuffer sb = new StringBuffer();
        String strHex = "";

        for (int i = 0; i < str.length(); i++) {
            c = str.charAt(i);
            intAsc = (int) c;
            strHex = Integer.toHexString(intAsc);

            if (intAsc > 128) {
                sb.append("\\u" + strHex);
            }
            //低位在前面补零
            if (!(intAsc > 128)) {
                sb.append("\\u00" + strHex);
            }
        }

        return sb.toString();
    }

    /**
     * 将Unicode字符串转化为普通字符串
     *
     * @param unicodeStr 需要转化的Unicode字符串(为一个16进制字符串) 一个unicode为2个字节
     * @return 转化完成的普通全角字符串 即一个字符占两个字节
     */
    public static String unicode2Str(String unicodeStr) {
        int t = unicodeStr.length() / 6;
        StringBuffer sb = new StringBuffer();

        for (int i = 0; i < t; i++) {
            String s = unicodeStr.substring(i * 6, i*6 + 6);
            //高位补上零
            String s_h = s.substring(2, 4) + "00";
            //低位直接转化
            String s_l = s.substring(4);
            //将16进制的string转化为int类型
            int n = Integer.valueOf(s_h, 16) + Integer.valueOf(s_l, 16);
            //将int类型转化为字符数组
            char[] chars = Character.toChars(n);
            sb.append(new String(chars));
        }

        return sb.toString();
    }

    /**
     * 获取Double字符串的小数点后两位的新字符串
     * @param parameter
     * @return
     */
    public static String getDecimalPointTowPlaceStr(String parameter){

        if(null == parameter){
            Log.e("TransStringUtil", "getDecimalPointTowPlaceStr: 参数为null 无法转化");
            return "0";
        }

        int point = parameter.lastIndexOf(".");

        if(point + 3 < parameter.length()){
            parameter = parameter.substring(0,point+3);
        }
        return parameter;
    }
}

